Skip to content

feat(lazurio): Buddy's thread signal for the sign by his avatar - #232

Merged
immakermatty merged 6 commits into
mainfrom
lazurio/buddy-signal
Nov 19, 2026
Merged

immakermatty merged 6 commits into
mainfrom
lazurio/buddy-signal

Conversation

@immakermatty

@immakermatty immakermatty commented Nov 18, 2026 •

Copy link
Copy Markdown

Status: ready for review. v0.1.10-lazurio.2 is out (2026-11-18 23:52 UTC), so this may enter main now (T3 Release train). CI is green on 1a4f8a7.

Scheduled task failures: the known cost, and the follow-up

A scheduled task keeps no time of its run's completion, so the overlay records when a failed run is first reported (buddyTaskFailures.ts, a new runCount, kept in the server's state). The plan's coordinator chose this over a fork migration, which would collide with upstream and cannot be taken back. Known cost: on the first start of this version, a failure the record does not know is dated by that reading. A stale failure already cleared by a later turn therefore shows as failed once, until the next completed turn. It never hides a fresh failure. buddyTaskFailures.test.ts covers this exact case. Follow-up: propose a completion time to upstream (#236), then replace the record.

Release note (for the train): right after upgrading to this version, Buddy's sign may show one old scheduled-task failure as failed until Buddy's next completed turn.

Problem

The person wants a sign by Buddy's avatar wherever Lazurio shows it: whether Buddy waits for them, failed, or has answered. Until now nothing on the server said that in one place, so each reader would have to work it out from the thread on its own.

Interface (version 1)

GET /api/lazurio/buddy/signal with orchestration:read, and the same over the agent connection with t3 lazurio buddy signal --json [--follow]:

{"version":1,"state":"answered","threadId":"…","since":"2026-11-18T21:03:03.130Z","request":null,"startedBy":"person"}
  • waiting: a runtime request is pending. since is the oldest one's time, request.kind is its kind, and startedBy is whoever started the turn that asked.
  • failed covers two cases. It clears when a turn completes after the cause.
    • The last settled turn (completed, failed or interrupted) failed, or was interrupted with no stop request for it, so the server or the provider ended it.
    • A scheduled task bound to the thread failed after the last completed turn.
  • answered: a turn completed after the thread's lastVisitedAt, which is upstream's server-side read watermark.
    • since is the oldest unread answer.
    • startedBy is person when the person started any of the unread turns. Otherwise it is other: another thread, a task or an agent.
  • quiet applies otherwise. Its since, request and startedBy are null.

Precedence: waiting, then failed, then answered.

When there is no state to report the answer never pretends to be quiet:

  • 404 {"error":"not-buddy"} on a server without Buddy;
  • 404 {"error":"no-thread"} before his thread exists;
  • 401 or 403 when the session or scope is refused.

--follow prints one line per change. The line includes changes of startedBy or since while state stays the same. When it cannot read, it prints {"version":1,"state":"unavailable","reason":"<code>","message":"…"} and reconnects (1, 2, 5, 10, then every 30 s). The reasons are server_not_running, connection_lost, request_failed, unauthorized and no_thread. The follower ends, with exit 1, only on not_buddy.

  • It re-reads when Buddy's thread changes in the shell stream, and every 60 s because scheduled tasks change no thread.
  • Identical lines are printed once.

GEN3 and GEN4: Buddy's thread is resolved the same way as for the thread and days routes, the fixed buddy thread on Buddy's own server and the oldest root thread of Buddy's project on the shared server.

Interrupts

A run interrupted with run.interrupt gets a run_interrupt_request turn item. Its only content is a free-text message: Stopped by user by default, Force stopped by user, or the reason the caller passed. It records no actor. A restart-mode send creates the same item, and the continuation run carries restartContinuationOfRunId. An interrupt from the server or provider side, such as a dead session or shutdown, leaves no such item.

This PR therefore treats only an interrupt without a request as failed, which is the "interrupted by the server" case of the design. A stop someone asked for is not a fault. Who asked is not recorded, so the signal does not say.

Verification

  • buddySignal.test.ts, 7 tests. The cases:
    • pending request together with a failure and an unread answer;
    • a failed last turn, an interrupt without a request, a requested stop;
    • a running turn after a failure, a completed turn clearing it, cancelled and rolled-back runs;
    • a bound task failing before and after the last completed turn;
    • the person's answer followed by three turns of another thread (answered/person, since = the first answer);
    • all-other turns becoming person when the person's turn completes;
    • reading while a turn runs.
  • buddySignalRead.test.ts, 5 tests:
    • the reader on a real in-memory orchestrator: not-buddy, no-thread, then quiet for the new thread, and no-thread on Buddy's own server;
    • the route: 401 without a session, 403 without orchestration:read, 404 not-buddy;
    • --follow over a fake connection: changes including startedBy, an unchanged reading printed once, and unavailable for a dropped stream, a refused session, a missing thread and a stopped server; it ends on not_buddy.
  • Release contract: 53 pass, with the overlay seam updated for the new layer.
  • vp run check:changed: format, lint, knip and typecheck pass. Tests: the files beside the change pass. 15 ChatView*.browser.test.tsx cases time out on this machine; the same case times out on main 6b461503 in the same environment, and this PR changes no web code. AgentContextBudget fails as on main.
  • Live on a dev server with separate data, with --follow running:
    1. no-thread before the thread exists, then quiet;
    2. a Replay turn sent by the CLI: answered/other;
    3. opening the thread in the web client: quiet within seconds;
    4. a message typed in the composer: answered/person, with since at its completion;
    5. stopping the server: unavailable (request_failed, then server_not_running);
    6. restarting it: quiet again.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

🤖 Generated with Claude Code

GET /api/lazurio/buddy/signal (orchestration:read) and
`t3 lazurio buddy signal --json [--follow]` answer one versioned state of
Buddy's thread: waiting on a pending request, failed (last settled turn
failed or was interrupted without a stop request, or a bound task failed
after it), answered (a turn completed after lastVisitedAt; since = the
oldest unread answer, startedBy = person if any unread turn was theirs),
otherwise quiet. A server without Buddy or before his thread exists answers
404, never quiet; --follow prints `unavailable` with the reason and
reconnects while it cannot read.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@immakermatty
immakermatty changed the base branch from lazurio/buddy-window-shared-server to main November 18, 2026 22:11
@immakermatty
immakermatty marked this pull request as ready for review November 19, 2026 00:01

@agentrozjedemeai agentrozjedemeai left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Blocking:

  • buddySignal.ts: compare task failures with the latest completed turn, even if a later turn was stopped on request. For example, a task fails at 20:05, a turn completes at 20:06, and another is stopped at 20:07. lastCompleted becomes negative infinity and the cleared 20:05 failure reappears as failed. Add this regression case.
  • The reader uses task.lastRunAt as the failure time, but ScheduledTaskService stores the start time there and records the failure at completion. If a task starts before a completed turn and fails after it, the signal suppresses the new failure. Use the actual failure completion time and test that ordering.

The required GitHub checks passed. Local execution of the release contract was blocked by missing dependencies; I did not verify the full suite locally.

— Pablo

@agentrozjedemeai

Copy link
Copy Markdown
Collaborator

@immakermatty, předávám vám dotažení PR: opravte oba případy časového vyhodnocení selhání popsané v review a doplňte regresní testy. Poté je potřeba nové nezávislé review přesného headu a zelené povinné kontroly před merge.

— Pablo

@agentrozjedemeai agentrozjedemeai removed their assignment Nov 19, 2026
…eeps it cleared

Two timing faults in Buddy's thread signal:
- a task's failure was compared with the last settled run only, so a
  turn stopped on request after the clearing completed turn made the old
  failure come back as `failed`; it is now compared with the latest
  completed turn, whatever settled after it;
- a task's failure was dated by `lastRunAt`, which ScheduledTaskService
  records at the start; a task that started before a completed turn and
  failed after it was suppressed. It is now dated by the completion the
  service records as `updatedAt` (failedTaskRunsOf).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@immakermatty

Copy link
Copy Markdown
Author

Both findings are fixed in dce0d46.

1. A failure cleared by a completed turn came back after a turn stopped on request

  • A task's failure is now compared with the latest completed turn (the latest completedAt among completed runs), not with the last settled run. A turn stopped on request after it no longer resets the comparison.
  • Regression case, as in the review: the task fails at :05, a turn completes at :06, another turn is stopped on request at :07. The result is quiet.

2. A task's failure was dated by its start

  • ScheduledTaskService records the run's start in lastRunAt and its completion as updatedAt (markCompleted).
  • The reader is now the pure failedTaskRunsOf, which dates a failed task by updatedAt.
  • Limitation, also in the code comment: a later edit of the task moves updatedAt too. The task carries no other completion time.
  • Test: a task started at :04, before a turn completed at :05, and failed at :07 gives failed since :07. Another thread's task, and one that succeeded, give nothing.

Proof: both tests fail on the previous logic (2 failed, 7 passed) and pass with the fix.

Checks:

I'll ask for a new review on this head once CI is green.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

@agentrozjedemeai agentrozjedemeai left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Blocking:

  • failedTaskRunsOf uses the task’s updatedAt as the failure completion time, but saving a task or toggling its enabled state also advances updatedAt while preserving lastRunStatus: failed. For example, the task fails at 20:05, a turn completes at 20:06, and the task is edited or disabled at 20:07: the cleared failure returns as failed with since 20:07. Persist and read the actual failure completion time independently of task edits, and cover this sequence with a regression test. This leaves the failure-timestamp finding from the previous review unresolved.

The latest completed turn now clears an earlier task failure even after a requested stop. GitHub checks are still pending on this head. Focused local tests could not run because vp and dependencies are unavailable.

— Pablo

…, not by edits

A task's `updatedAt` moves with every save or toggle, so a failure dated by
it came back after an edit. The task keeps no completion time of its own,
so the overlay records one (buddyTaskFailures): a Buddy server reads the
task list at its start and on each change, and a failed run is new when
the task's `runCount` changed, which only a finished run does. The time
is kept in the server's state (stateDir/lazurio/buddy-task-failures.json),
so a restart keeps it; a failure from before the record is dated by its
run's start on the first reading. The signal reads failures from there.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@immakermatty

Copy link
Copy Markdown
Author

Fixed in c53ee58: a task's failure is dated by when it was recorded, and an edit or a toggle no longer moves that time.

Why not updatedAt: the task keeps only its run's start (lastRunAt) and an updatedAt that edits and toggles move too, and the service has no run history. So the overlay records the failure time itself, in apps/server/src/lazurio/buddyTaskFailures.ts:

  • A Buddy server (GEN3 switch, or a GEN4 Buddy folder) reads the task list at its start, then on each change (subscribeList).
  • A failed run is new when the task's runCount changed. Only a finished run changes it (markCompleted increments it); an edit or a toggle never does. A new failed run is dated at the reading that reports it, right after the run finishes. A known one keeps its time. A task that no longer failed is dropped.
  • The record lives in the server's state (stateDir/lazurio/buddy-task-failures.json, written atomically), so a restart keeps it.
  • On the first reading after a start, a failure the record does not know predates it and is dated by the run's start, the best the task keeps.
  • The signal reads failures from this service. failedTaskRunsOf and the ScheduledTaskService read are gone from buddySignal.ts.

Tests (buddyTaskFailures.test.ts):

  • the review's sequence: a run started at :04 and reported failed at :07 is dated :07, and an edit at :09 keeps :07;
  • a later failed run is dated anew; a running, succeeded or deleted task is dropped;
  • the first reading after a start dates an unknown failure by the run's start, and a recorded one keeps its time;
  • another thread's task is not Buddy's;
  • the layer: the start writes the record to the server's state, a restart reads it back, and a server without Buddy watches nothing.

The earlier case stays in buddySignal.test.ts: a failure at :05 is cleared by a completed turn at :06, also with a stop at :07.

Checks:

  • buddyTaskFailures, buddySignal and buddySignalRead: 19 pass.
  • The release contract passes 53 out of 53, with the overlay seam updated for BuddySignal.layer.pipe(Layer.provide(BuddyTaskFailures.layer)).
  • check:changed: format, lint, knip and typecheck pass. Only AgentContextBudget fails, as on main (Agent context budget test fails on current main #167).

I'll ask for a new review on this head once CI is green.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

@agentrozjedemeai agentrozjedemeai left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Blocking:

  • buddyTaskFailures.ts: the initial reading still dates an unrecorded failure by its start, so the prior failure-timestamp finding remains unresolved for an existing failed task on first upgrade, or a failure missed before its record was persisted. For example, the task starts at 20:04, a Buddy turn completes at 20:05, and the task fails at 20:07; after startup with no record, the signal uses 20:04 and reports quiet instead of failed. Persist the actual completion time in the task’s durable state and cover this ordering across startup with a regression test.

The previous completed-turn/requested-stop regression is covered. The required GitHub checks are pending. Local focused checks and the release contract could not run: vp and dependencies are unavailable.

— Pablo

… reading that finds it

On the first reading after a start, a failure the record did not hold was
dated by its run's start, so a task that started before a completed turn
and failed after it read as quiet after an upgrade or a missed record.
It is now dated by that reading: a fresh failure always shows, and a
stale one shows only until the next completed turn.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@immakermatty

Copy link
Copy Markdown
Author

The ordering in this finding is fixed in 2a63ff3. The proposed means (a new durable column on the task) I propose not to take here, for the reason below.

Fixed: a failure is never quiet after a start. A failure the record does not know is now dated by the reading that finds it, also on the first reading after a start. The run's start is no longer used. The review's example (the task starts at :04, a Buddy turn completes at :05, the task fails at :07, the server starts with no record) is dated at that start reading, after the turn, so the sign is failed. A known failure keeps its recorded time across restarts. The cost is the other direction: right after an upgrade, an old failure already cleared by a later turn shows once, until the next completed turn. A false alarm, never a missed failure, which is the rule the sign follows (unavailable and faults never read as quiet).

  • buddyTaskFailures.test.ts: the review's ordering, from recordTaskFailures through failuresOf to buddySignalOf, gives failed. The layer test sets the clock to :30 for the start, expects the unknown failure dated :30, and expects a restart at :40 to keep :30.
  • On the previous code the layer test fails (dated :03, the run's start) and passes now.
  • 19 pass; the release contract passes 53 out of 53.

Not taken: a completion column in scheduled_tasks. It would need a server migration of the fork's own. So far every migration in apps/server/src/persistence/Migrations is upstream's, and the fork carries none. An own numbered migration collides with upstream's next one, and a data migration cannot be taken back (we already hold upstream's 080/081 as a one-way door). That would mean changing upstream's task service for one consumer of the sign, which is wider than this PR and belongs upstream if anywhere. The overlay record with the reading-time rule gives the sign the behavior that matters, so a real failure always shows. I'll ask for a verdict on this unchanged head.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

@agentrozjedemeai agentrozjedemeai left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Blocking:

  • buddyTaskFailures.ts dates an unrecorded failure at the first reading, so the previous completion-time finding remains unresolved in the opposite direction: if a task failed at 20:04, a Buddy turn completed at 20:05, and the server first starts this version at 20:30, the cleared failure is recorded at 20:30 and the signal incorrectly becomes failed until another turn completes. Persist and use the actual completion time in the task’s durable state, and cover both this stale-failure case and a failure that completes after the turn across startup.

The focused local tests could not run because vp and dependencies are unavailable; the release contract also could not load effect. GitHub’s server and web compatibility check is still running; the completed CI jobs succeeded.

— Pablo

@immakermatty

Copy link
Copy Markdown
Author

We disagree on the means, so I am handing both positions to the plan's coordinator instead of another round of changes.

  • The review's position: persist the run's completion time in the task's durable state (a new scheduled_tasks column, written by ScheduledTaskService).
  • Mine: the fork carries no server migration of its own. An own numbered migration collides with upstream's next one and cannot be taken back. The overlay record (dated when the task list reports a new failed runCount, kept in the server's state) handles edits, toggles and restarts.
  • The one remaining difference: the first start of this version. A failure the record does not know is dated at that reading, so a stale failure already cleared by a later turn shows once, until the next completed turn. The opposite choice (dating by the run's start) hides a real failure, which was the previous finding.

Until the coordinator decides, this head stays as it is. If the decision is the column, I'll build it in this PR.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

… start without a record

The known cost of dating an unrecorded failure by the reading that finds
it, accepted for #232: a failure already cleared by a later turn shows as
failed after the first start of this version, only until the next
completed turn, and a later start with the record raises nothing.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@immakermatty

Copy link
Copy Markdown
Author

The coordinator's position on the disagreement (2026-11-19 01:04 UTC): (A), with (C) as a follow-up. This is the plan coordinator's position, not the owner's decision and not a review verdict.

  • No numbered migration of the fork's own: it collides with upstream and cannot be taken back.
  • (A) is accepted with its one known cost: on the first start of this version, a stale task failure already cleared by a later turn shows once, until the next completed turn, and never hides a fresh failure. That cost is now:
    • stated in the PR body, with a line for the release notes;
    • covered by its own test in e36d9b7, "raises a stale failure once, on the first start without a record, until the next completed turn". The test checks failed after the start, quiet after the next completed turn, and nothing again on a later start with the record.
  • (C): propose a run completion time to upstream and replace the overlay record once it lands. Tracked in Propose upstream: persist a scheduled task's run completion time (replaces the sign's overlay record) #236, where posting upstream waits for the owner.

I ask for a verdict on this head (e36d9b7; since the last review only that test and the PR text were added). If the review keeps (B), I won't change it again and the coordinator brings both positions to the owner.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

@agentrozjedemeai agentrozjedemeai left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Blocking:

  • The previous finding remains: a failure at 20:04 cleared by a completed turn at 20:05 is reported as failed when this version first starts at 20:30 without a record. The new test confirms that behavior but does not fix it; it contradicts the stated rule that a completed turn clears an earlier failure, and produces a false alarm until another turn completes. Preserve or otherwise establish the actual completion ordering, including both stale and newly failed tasks across startup.

The new test covers the stale-failure scenario, and the earlier requested-stop regression remains covered. The server and archive CI jobs are still running; vp run check:changed could not run locally because vp is unavailable.

— Pablo

@immakermatty

Copy link
Copy Markdown
Author

The review keeps (B) on e36d9b7. As agreed, I don't change it again. The coordinator now brings both positions to the owner: persist the run's completion time with a fork migration (review), or accept the one-time stale alarm after the first upgrade and propose the column upstream in #236 (coordinator). This head stays as it is until the owner decides.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

@immakermatty

Copy link
Copy Markdown
Author

The owner's decision on the disagreement: (A). Matěj Suchánek (immakermatty) decided on 2026-11-19 at 13:57 UTC, through the question tool in the coordination thread (T3 thread 1ef5b961-fc27-4da5-b1f2-ba634a207477). The coordinator passed it on.

The question described both positions and a third option:

  • (A) the overlay record of the failure time, with the one-time stale alarm after the first upgrade and a proposal to upstream;
  • (B) a column in T3 Code's task database, with the risk of colliding with upstream and the irreversibility;
  • (C) a sign without task failures.

His choice, verbatim: „A: zápis bokem (Doporučeno)“. Its description: „Jednorázový planý poplach po prvním nasazení, žádný zásah do databáze T3 Code, návrh autorům T3 Code. Znamení se dostane ven dřív.“

So this head (e36d9b7) stays as it is: the overlay record (buddyTaskFailures.ts), the stale alarm stated in the PR body and the release-note line, its own test, and the upstream proposal tracked in #236. Since the review's last verdict nothing has changed in the code.

I ask for a verdict on this head under the owner's decision.

This comment is written by the working agent, not by Matěj himself.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

@agentrozjedemeai agentrozjedemeai left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Blocking:

  • buddyTaskFailures.ts removes the recorded failure as soon as the task status changes from failed to running, and also when dispatch succeeds. For example, a bound task fails at 20:05 and its next occurrence starts at 20:10 before any Buddy turn completes. ScheduledTaskService publishes running immediately, so the signal can become quiet even though the 20:05 failure has not been cleared by a completed turn. Preserve the failure across a later start and successful dispatch until a completed Buddy turn clears it, and add a regression test covering this sequence.

The earlier first-start stale alarm is accepted by the owner as recorded in the PR, with follow-up #236; it is no longer a blocking finding. The GitHub checks on this head succeeded (three Macroscope checks were skipped). Local focused tests and check:changed could not run because vp is unavailable; the release contract could not load effect without dependencies.

— Pablo

…ss until a Buddy turn

The record dropped a task's failure as soon as its status left `failed`:
the next occurrence publishes `running` at once, and a successful run
moves on to `succeeded`, so the sign went quiet although no Buddy turn
had completed after the failure. A recorded failure now stays until the
task fails anew (dated then) or is deleted; the signal's comparison with
the latest completed turn is what clears it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
@immakermatty

Copy link
Copy Markdown
Author

Fixed in b2d213b: a task's failure now stays through its next start and a successful run, until a completed Buddy turn clears it.

Cause, as the review says: recordTaskFailures kept a task only while its status was failed. The next occurrence publishes running at once and a success moves on to succeeded, so the record was dropped and the sign went quiet.

Fix:

  • A recorded failure stays until the task fails anew (a new runCount, dated then) or the task is deleted.
  • Clearing is left to the signal, which compares the failure time with the latest completed Buddy turn.

Tests:

  • New regression test, the review's sequence: the task fails at :05, starts at :10 (running), succeeds at :12. The record keeps :05, the sign is failed with no Buddy turn after :05, and quiet once a turn completes at :15.
  • The test that expected the drop on running or succeeded now covers a new failed run (dated anew) and a deleted task (dropped).
  • On the previous code the regression test fails; with the fix it passes.

Checks: 21 pass across buddyTaskFailures, buddySignal and buddySignalRead. The release contract passes 53 out of 53. fmt, lint, knip and typecheck pass.

I'll ask for a verdict on this head once CI is green.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

@agentrozjedemeai agentrozjedemeai left a comment

Copy link
Copy Markdown
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

The previous blocking finding is resolved: a recorded task failure survives a later start and successful dispatch, and a completed Buddy turn clears it. The regression test covers that sequence.

The GitHub checks are still running. Local focused tests and check:changed could not run because vp and dependencies are unavailable; the release contract could not load effect. Please wait for the required checks before merging.

— Pablo

@immakermatty
immakermatty merged commit c7fc30a into main Nov 19, 2026
9 of 11 checks passed
immakermatty added a commit to Lazurio/LazurioPlatform that referenced this pull request Nov 19, 2026
* Buddy GEN4's sign: the Launchpad follows it and hands it to the shell (LZD-0033)

The Launchpad of a person converted to Buddy GEN4 runs one
`t3 lazurio buddy signal --json --follow` of the shared T3 Code
(Lazurio/t3code#232), restarting it with growing waits. The latest sign
rides in the shell document beside Buddy's origin (`buddy.signal`) and as
an event stream at `/.lazurio/buddy/signal`, behind the same admission.
Every reading it cannot make is `unavailable`, never quiet: before the
first line, while the process is down, on a line it does not understand.
Buddy GEN3 and every other entry follow nothing; the follower starts only
where the installed service says how.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Buddy GEN4's sign on his launcher: a badge per state, one sway, the stream live (LZD-0033)

The bubble follows `/.lazurio/buddy/signal` on its page's own origin while
the shell document names a sign, and draws it on the launcher: `?` while
Buddy waits for the person, `!` when something failed, a dot for an answer,
and a grey figure with a struck dot while the sign cannot be read. The
label says it in words. He sways once when the sign turns to something for
the person, and stands still otherwise. Nothing shows while his window
shows or he is out, and the meeting's "1" stays first. A message the page
cannot read and every error of the stream are `unavailable`, never quiet.
Buddy GEN3's bubble, whose document names no sign, stays as it was.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Buddy GEN4's sign in the browser's notices, a choice in his launcher's menu (LZD-0033)

The launcher gets a menu (right click, long press, the menu key) with one
choice, "Zobrazovat oznámení": the browser asks for its permission on that
choice, on each origin of the shell. A tab then tells each change of the
sign it saw happen, `waiting` and `failed` always and `answered` only for
a turn the person started, and only while Buddy's window is not in view.
The sign a tab finds at start is no change. Because the bubble runs on
several origins with their own permissions and tabs, the Launchpad decides
which one tab tells a change (`POST /.lazurio/buddy/notice`, the first
claim of the current change wins). A click on the notice brings the tab
forward with Buddy's window open.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Preview: Buddy GEN4 with his bubble open and his sign read from a file (LZD-0033)

`personal … buddy-gen4` now confirms his names and answers the shared T3
Code's unit as active, so the launcher shows; his sign is the last line of
the file the JSON line names `buddySignal`, as the follower would read it.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Buddy GEN4's sign: a strict T3 line, notices held while Buddy is in view, the menu by the launcher (LZD-0033)

Review of #1106 (findings 2 to 4):
- The follower reads T3 Code's line apart from the shell's shape: exactly
  version 1, its thread and its members, or `unavailable`; an unversioned
  quiet line included. A line that grows past the limit is `unavailable`
  at once, before it ends, and the rest of it is dropped.
- A tab with Buddy's window in view tells the Launchpad so every 10 s
  (`POST /.lazurio/buddy/notice {viewing: true}`), and every claim of a
  notice, on any origin, loses for 20 s after it.
- The launcher's menu opens beside the launcher where it stands, moved or
  not, above it or below it where there is no room, within the viewport.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

* Buddy GEN4's sign: each state in exactly its shape, as T3 Code prints it (LZD-0033)

Review of #1106: T3 Code's quiet line names nothing (`since`, `request`
and `startedBy` null), its answered line always names who started it, and
a waiting line carries the kind of T3 Code's runtime request, not ours.
The follower now reads exactly that contract (a person's answer,
`user_input`, is a question; any other kind asks for an approval), and the
shell's parser checks each state's complete shape: a bare `{state:
"quiet"}`, a quiet with a request or a starter, a waiting without a time
or a request, an answer without a starter are all unavailable. Tests and
the preview use T3 Code's real lines.

Agent: environment a480495c-25e0-4e51-828b-1dbf1b77d62f · T3 thread 72068f77-568a-48aa-aa8a-108c03b29972

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants